%load_ext pretty_jupyter

import pandas as pd
import os
import numpy as np

from mlxtend.frequent_patterns import fpgrowth
from mlxtend.frequent_patterns import association_rules

os.chdir("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2")

genero_user_treino1 = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/genero_user_treino1.pickle", compression='gzip')
genero_user_teste1 = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/genero_user_teste1.pickle", compression='gzip')

genero_user_treino1

recomendacao_genero_treino1 = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/recomendacao_genero_treino1.pickle", compression='gzip')
recomendacao_genero_teste1 = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/recomendacao_genero_teste1.pickle", compression='gzip')

recomendacao_genero_treino1

recomendacao_genero_teste1

# Verificar o tipo de dados na tabela de treino
recomendacao_genero_treino1.dtypes

# Transformar as dummies em int8
recomendacao_genero_treino1= recomendacao_genero_treino1.astype(np.int8)
recomendacao_genero_teste1= recomendacao_genero_teste1.astype(np.int8)

#Transformar 'userId' em índice
recomendacao_genero_treino1.set_index('userId', inplace=True)
recomendacao_genero_teste1.set_index('userId', inplace=True)

# Verificar se todos os valores são 0 ou 1 (verificar se a transformação int8 deu certo)
valores_binarios_treino = recomendacao_genero_treino1.apply(lambda x: x.isin([0, 1]).all()).all()
print("O DataFrame de treino contém apenas valores binários (0 ou 1)?", valores_binarios)

# Verificar se todos os valores são 0 ou 1 (verificar se a transformação int8 deu certo)
valores_binarios_teste = recomendacao_genero_teste1.apply(lambda x: x.isin([0, 1]).all()).all()
print("O DataFrame de teste contém apenas valores binários (0 ou 1)?", valores_binarios)

recomendacao_genero_treino1

recomendacao_genero_teste1

# Aplicar algoritmo nos dados de treino
frequent_items_fp = fpgrowth(recomendacao_genero_treino1, min_support=0.01, use_colnames=True)

print("Itens frequentes encontrados:")
print(frequent_items_fp.head())

# Gerar regras de associação
rules_fp = association_rules(frequent_items_fp, metric="lift", min_threshold=0.8)

rules_fp

def apply_association_rules(user_data, rules)->pd.DataFrame():
    ''' Função que associa userId e recomendações de gênero.
        Esta função é utilizada após a execução do algoritmo FP_Growth() 
        e a criação das regras de associação.

    Args:
    - user_data: Um conjunto de dados contendo informações sobre os usuários e seus filmes assistidos.
    - rules: Um conjunto de regras de associação geradas pelo algoritmo FP Growth, 
            que indicam relações frequentes entre gêneros de filmes.

    Return:
    - A função retorna um pd.DataFrame() com as recomendações para cada usuário 
      com base nas regras de associação.
    '''
    recommendations = []
    
    # Iterar user_data agrupado por userId
    for user_id, data in user_data.groupby('userId'):
        user_preferences = set(data['genres'])  
        user_recommendations = []
        
        used_genres = set()  # Conjunto para controlar gêneros já utilizados
        
        for idx, rule in rules.iterrows():
            antecedents = set(rule['antecedents'])
            consequents = set(rule['consequents'])
            
            if antecedents.issubset(user_preferences):
                for item in consequents:
                    if item not in user_preferences and item not in used_genres:
                        user_recommendations.append(item)
                        used_genres.add(item)  # Marca o gênero como utilizado
            
        
        # Preencher com None se tiver menos de 2 recomendações
        while len(user_recommendations) < 3:
            user_recommendations.append(None)
        
        recommendations.append({'userId': user_id,
                                'Recomendacao_genero_1': user_recommendations[0],
                                'Recomendacao_genero_2': user_recommendations[1],
                                'Recomendacao_genero_3': user_recommendations[2]})

    recommendations_df = pd.DataFrame(recommendations)
    return recommendations_df

# Filtrar apenas regras com um lift alto, por exemplo
rules_high_lift = rules_fp[rules_fp['lift'] > 1.5]

# Aplicar regras de associação aos dados de teste
user_recomendacoes_teste1 = apply_association_rules(genero_user_teste1 , rules_high_lift)

# Tabela com as recomendações de gênero
user_recomendacoes_teste1

# Contagens de gêneros recomendados em primeiro lugar
user_recomendacoes_teste1['Recomendacao_genero_1'].value_counts().to_frame()

# Verificar quantos valores None existem em cada coluna
none_counts = user_recomendacoes_teste1.isna().sum()

# Exibir os resultados
print("Quantidade de None por coluna:")
print(none_counts)

def filtrar_filmes_por_genero(dataframe, generos_unicos):
    # Inicializar um dicionário para armazenar os DataFrames filtrados por gênero
    filmes_por_genero = {}

    # Iterar sobre cada gênero único
    for genero in generos_unicos:
        # Filtrar os filmes por gênero
        filmes_do_genero = dataframe[dataframe['genres_separado'] == genero]
        
        # Ordenar filmes_do_genero pela rating_medio_ponderado em ordem decrescente
        filmes_do_genero = filmes_do_genero.sort_values(by='rating_medio_ponderado', ascending=False)

        # Remover duplicatas de filmes baseado no título, mantendo apenas o primeiro (com a maior pontuação)
        filmes_do_genero = filmes_do_genero.drop_duplicates(subset='title')

        # Selecionar os top 2 filmes com as maiores pontuações
        top_2_filmes = filmes_do_genero.head(2)

        # Adicionar ao dicionário com a chave sendo o nome do gênero
        filmes_por_genero[genero] = top_2_filmes

    # Retornar o dicionário de DataFrames filtrados por gênero
    return filmes_por_genero

# Lista dos gêneros do dataset
lista_generos = list(genero_user_treino1['genres_separado'].unique())
print(lista_generos)

# Filtrar os filmes por gênero e armazenar em um dicionário
filmes_por_genero = filtrar_filmes_por_genero(genero_user_treino1, lista_generos )

# Filtrar os filmes de ação
genero_acao = filmes_por_genero['Action']
genero_acao

# Passo 1: Obter recomendações de filmes por gênero usando a função filtrar_filmes_por_genero
filmes_por_genero_teste = filtrar_filmes_por_genero(genero_user_teste1, lista_generos)


# Passo 2: Criar uma lista para armazenar as recomendações finais
recomendacoes_finais = []

# Passo 3: Iterar sobre cada userId e suas recomendações de gênero e filmes
for user_id, recomendacoes_genero in user_recomendacoes_teste1.iterrows():
    user_id = recomendacoes_genero['userId']  # Extraindo o userId corretamente
    # Inicializar as recomendações de filmes para este userId
    recomendacoes_filmes = {
        'userId': user_id,
        'Recomendacao_genero_1': recomendacoes_genero['Recomendacao_genero_1'],
        'Recomendacao_genero_2': recomendacoes_genero['Recomendacao_genero_2'],
        'Recomendacao_genero_3': recomendacoes_genero['Recomendacao_genero_3'],
        'Recomendacao_filme_1': None,
        'Recomendacao_filme_2': None,
        'Recomendacao_filme_3': None,
        'Recomendacao_filme_4': None,
        'Recomendacao_filme_5': None,

    }
    
    # Contador para acompanhar o número de recomendações preenchidas
    count_recomendacoes = 0
    
    # Iterar sobre as recomendações de gênero para este userId
    for coluna_genero, genero_recomendado in recomendacoes_genero.items():
        # Verificar se há um gênero recomendado
        if pd.notna(genero_recomendado) and genero_recomendado in filmes_por_genero_teste:
            # Pegar os top 2 filmes para este gênero
            filmes_genero = filmes_por_genero_teste[genero_recomendado].head(2)['title'].tolist()
            
            # Preencher as recomendações de filmes vazias na ordem até o máximo de 3
            for i, filme in enumerate(filmes_genero):
                if count_recomendacoes < 5:
                    if pd.isna(recomendacoes_filmes[f'Recomendacao_filme_{count_recomendacoes + 1}']):
                        recomendacoes_filmes[f'Recomendacao_filme_{count_recomendacoes + 1}'] = filme
                        count_recomendacoes += 1
    
    # Adicionar as recomendações deste userId à lista final
    recomendacoes_finais.append(recomendacoes_filmes)

# Passo 4: Criar o DataFrame final com as recomendações de filmes e gêneros
recomendacoes_finais_df = pd.DataFrame(recomendacoes_finais)

# Tabela com as recomendações 
recomendacoes_finais_df

# Verificar a quantidade de NA (falta de recomendação)
recomendacoes_finais_df.isna().sum()

# Função para criar a coluna dummy
def assistiu_ou_nao(row, df_teste):
    user_id = row['userId']
    recomendacoes = row.drop('userId').values
    
    if len(recomendacoes) == 'None':
        return 2
    
    if user_id in df_teste.index:
        for filme in recomendacoes:
            if filme in df_teste.columns and df_teste.loc[user_id, filme] != 0:
                return 1
    
    return 0

# Aplicar a função a cada linha do DataFrame de recomendações
recomendacoes_finais_df['Assistiu'] = recomendacoes_finais_df.apply(assistiu_ou_nao, axis=1, df_teste=recomendacao_genero_teste1)

# Tabela final das recomendações
recomendacoes_finais_df_com_assistiu

# Salvar a tabela
recomendacoes_finais_df_com_assistiu.to_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/4.Modelagem_FP_Growth/recomendacoes_finais_df_com_assistiu", compression="gzip")

# Avaliar a qualidade das recomendações
recomendacoes_finais_df_com_assistiu[['Assistiu']].value_counts()